package com.itheima.consumer.listeners;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Slf4j
@Component
public class MqListener {
    //    收到消息之后在这儿处理消息  监听一个队列！！！
//    模型1： 生产者  发送消息生产者发送消息到队列  队列有一个消费者
    @RabbitListener(queues = "wy001queues")
    public void listenSimpleQueue1(String msg) {
        System.out.println("消费者收到了simple.queue的消息：【" + msg + "】");
    }

    /**
     * #    充分利用每一台机器的性能。
     * #  一个消费者最多拿一条消息，不要多拿。 消费完这条消息才能取消息，  加快处理速度  能者多劳  解决消息处理的速度。避免堆积问题
     * 做这个配置就可以了。
     * listener:
     * simple:
     * prefetch: 1
     */

    //    模型2： 生产者  发送消息生产者发送消息到队列  队列有一个消费者
    //    默认是轮询机制，一个消费者消费一个消息
    @RabbitListener(queues = "wy002queues")
    public void listenSimpleQueue2_1(String msg) throws InterruptedException {
        System.out.println("消费者1 收到了 work.queue的消息...... ：【" + msg + "】");
        Thread.sleep(20);
    }

    @RabbitListener(queues = "wy002queues")
    public void listenSimpleQueue2_2(String msg) throws InterruptedException {
        System.err.println("消费者2 收到了 work.queue的消息...... ：【" + msg + "】");
        Thread.sleep(200);
    }


    @RabbitListener(queues = "fanoutEx.q1")
    public void listenFanoutQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1 收到了 fanout.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(queues = "fanoutEx.q2")
    public void listenFanoutQueue2(String msg) throws InterruptedException {
        System.out.println("消费者1 收到了 fanout.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(queues = "directEx.q1")
    public void listenDirectQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1 收到了 fanout.queue2的消息：【" + msg + "】");
    }

    @RabbitListener(queues = "directEx.q2")
    public void listenDirectQueue2(String msg) throws InterruptedException {
        System.out.println("消费者2 收到了 fanout.queue2的消息：【" + msg + "】");
    }

    @RabbitListener(queues = "topicEX.q1")
    public void listenTopicQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1 收到了 topic.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(queues = "topicEX.q2")
    public void listenTopicQueue2(String msg) throws InterruptedException {
        System.out.println("消费者2 收到了 topic.queue2的消息：【" + msg + "】");
    }


//    这几个参数：  申明队列，申明交换机，申明交换机类型， 申明队列何炅交换机的绑定关系的key，可以是多个。
//    durable的意思是  是否是持久的，是否会保存在交换机rabbitMQ里面
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1", durable = "true"),
            exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),
            key = {"red", "blue"}
    ))
    public void listenDirectQueue1_1(String msg) throws InterruptedException {
        System.out.println("消费者1 收到了 direct.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2", durable = "true"),
            exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),
            key = {"red", "yellow"}
    ))
    public void listenDirectQueue2_1(String msg) throws InterruptedException {
        System.out.println("消费者2 收到了 direct.queue2的消息：【" + msg + "】");
    }

//    序列化的问题：  如果传递的是一个对象，我们使用json序列化， json反序列化这个对象
    @RabbitListener(queues = "object.queue")
    public void listenObject(Map<String, Object> msg) throws InterruptedException {
        System.out.println("消费者 收到了 object.queue的消息：" + msg);
    }
}
